﻿// 8. 关系、逻辑、逗号运算及优先级.cpp 

/*
关系运算用于比较两个表达式的值，运算的结果为 1-true 和 0-false。

1）关系运算
关系      数学的表示          C++的表示
等于          =                   == 
不等于        ≠                  !=
小于          <                   <
小于等于      ≤                  <= 
大于          >                   >
大于等于      ≥                  >= 

注意：
    关系运算符的两边可以是数值，也可以是表达式；
    用 std::cout 输出关系运算表达式时，关系表达式要加括号；
    关系运算也适用于字符串（string），字符串常用的关系运算是 == 和 != ，其它的基本上不用
*/

/*
#include<iostream> 
using namespace std;            // 指定缺省的命名空间。
int main()
{
    int a = 7;
    int b = 7;
    bool result;
    result = a <= b - 3;                      // a 和 b 先做比较(关系)运算，然后再赋值给 result。
    cout << "result = " << result << endl;    // 关系运算表达式需要括号，算术运算表达式可以不用括号。

    string str1 = "西施";
    string str2 = "西瓜";
    cout << "(str1 != str2) = " << (str1 != str2) << endl;          //(str1 != str2)为真，输出1
}
*/


// 逻辑运算
// 根据给定的逻辑因子（表达式或值）返回一个新的逻辑因子。

/*
   运算符        术语            示例                        结果
     &&          逻辑与         a&& b;              如果 a 和 b 都为真，则结果为真，否则为假。
     ||          逻辑或         a || b;             如果 a 和 b 中有一个为真，则结果为真，二者都为假时，结果为假。
     !           逻辑非（反）     !a;               如果 a 为假，则!a 为真； 如果 a 为真，则!a 为假。

注意：
 逻辑运算符的两边可以是数值，也可以是表达式；
 用 std::cout 输出逻辑运算表达式时，逻辑表达式要加括号；
 在实际开发中，逻辑运算的多重组合是重点。

*/

/*
#include<iostream>
using namespace std;
int main()
{
    // 超女必须满足四个条件：年龄 25 岁以下，身高 165 以上、体重 50 公重以下，颜值要漂亮。
    string name="西施";
    int age=18;
    double height = 155.8;
    double weight = 44.5;
    bool yz = true;
    // 用 std::cout 输出逻辑运算表达式时，逻辑表达式要加括号；
    cout << "result = " << (age < 25 && height> 155 && weight < 50 && yz == true) << endl;
    cout << endl;

    bool a = false;
    bool b = true;
    bool c = a && b;           // 如果 a 和 b 都为真，则结果为真，否则为假。
    bool d = a || b;           // 如果 a 和 b 中有一个为真，则结果为真，二者都为假时，结果为假。
    bool e = !a;               // 如果 a 为假，则!a 为真； 如果 a 为真，则!a 为假。
     cout << "c=" << c << endl;
     cout << "a&&b=" << (a && b) << endl;
     cout << "a||b=" << (a || b) << endl;
    cout << "!a=" << e << endl;
}
*/



// 逗号运算,把一行语句中的多个表达式连接起来，程序将从左到右执行表达式。
// 语法：表达式1, 表达式2, ……, 表达式 n;
// 逗号运算常用于声明多个变量

/*
#include<iostream>
using namespace std;
int main()
{
    //int a, b;                      // 声明变量 a 和 b。
    int a = 10, b = 20;              // 声明变量 a 和 b 并初始化。
    //也可以用于其它语句中，但是，逗号运算符是所有运算符中级别最低的，以下两个表达式的效果是不同的
    cout << "a = " << a << endl;      // a = 10
    cout << "b = " << b << endl;      // b = 20

    int v,n ,m;                           
    v = n = 2, n * 2;                    //  不加括号，只赋值2      
    m = (n = 2, n * 2);                  //  加了括号，计算最后的表达式，m=4

    cout << "v = " << v << endl;         // v = 2
    cout << "n = " << n << endl;         // n = 2
    cout << "m = " << m << endl;         // m = 4
}
*/

// 运算的优先级

/*
一个表达式可以包含多个运算符，运算符的优先级决定了表达式各部分的执行顺序。
例如，按照运算规则， * 的优先级比 + 高，所以的 b * c 将先执行：

  如果一个表达式中操作符的优先级相同，那么它们的结合律（associativity）决定了它们的执行顺序
  （从左到右或从右到左）。例如，算术运算的组合方式是从左到右，赋值运算则是从右到左。如下：
  表达式          结合律             组合方式
a / b % c        从左到右           (a / b) % c
a = b = c        从右到左            a = (b = c)

*/

/*
#include<iostream>
using namespace std;
int main()
{
    int a = 1, b = 2, c = 3;
    int  d = 4, e = 5;

    d = a + b * c;                                // d = 7
    //如果想让 a + b 先执行，则必须使用括号：
    e = (a + b) * c;                              // e = 9

    cout << "d = " << d << endl;
    cout << "e = " << e << endl;
}
*/


//下表是全部运算符的优先级和结合律：
/*
    优先级     运算符      名称或含义                 使用形式                      结合方向
      1
                []           下标                    地址[表达式]                     左到右
                ()           圆括号                  (表达式)/函数名(形参表)
                 .        成员选择(对象)             对象.成员名
                ->        成员选择（指针）           对象指针->成员名
      2
                -           负号运算符               - 表达式                          右到左
              (类型)        强制类型转换             (数据类型)表达式
                ++          前置自增运算符           ++变量名
                ++          后置自增运算符           变量名++
                --          前置自减运算符           --变量名
                --          后置自减运算符           变量名-- 
                *           取值运算符               * 指针变量
                &           取地址运算符             & 变量名
                !           逻辑非运算符             !表达式
                ~           按位取反运算符           ~表达式 
               sizeof       长度运算符               sizeof(表达式)
     3
                 /          除                       表达式/表达式                     左到右
                 *          乘                       表达式 * 表达式
                 %          余数(取)                 整型表达式/整型表达式
     4
                 +          加                       表达式 + 表达式                   左到右
                 -          减                       表达式 - 表达式
     5
                 <<         左移                     变量                              左到右
                 >>         右移                     变量 >> 表达式
     6
                 >          大于                     表达式 > 表达式                   左到右
                 >=         大于等于                 表达式 >= 表达式
                 <          小于                     表达式
                 <=         小于等于                 表达式
     7 
                 ==         等于                     表达式 == 表达式                  左到右
                 !=         不等于                   表达式 != 表达式
     8
                 &          按位与                   表达式 & 表达式                    左到右
     9 
                 ^          按位异或                 表达式 ^ 表达式                    左到右
    10 
                 |          按位或                   表达式 | 表达式                    左到右
    11
                 &&         逻辑与                   表达式 && 表达式                   左到右
    12 
                 ||         逻辑或                   表达式 || 表达式                   左到右
    13 
                 ? :        条件运算符               表达式 1 ? 表达式 2 : 表达式 3      右到左
    14 
                  =         赋值运算符                变量 = 表达式                      右到左
                 /=         除后赋值                  变量 /= 表达式
                 *=         乘后赋值                  变量 *= 表达式
                 %=         取模后赋值                变量 %= 表达式
                 +=         加后赋值                  变量 += 表达式
                 -=         减后赋值                  变量 -= 表达式
                 <<=        左移后赋值                变量
                 >>=        右移后赋值                变量 >>= 表达式
                 &=         按位与后赋值              变量 &= 表达式
                 ^=         按位异或后赋值            变量 ^= 表达式
                 |=         按位或后赋值              变量 |= 表达式
    15
                  ,         逗号运算符                表达式, 表达式,…                   左到右
    注意：
     如果不确定运算符的优先级，可以加括号；
     多用括号，让代码的可读性更好。
 */